home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / program / szadb1_4.zoo / src / dis3.c < prev    next >
C/C++ Source or Header  |  1990-11-13  |  16KB  |  817 lines
  1. /* Copyright (c) 1990 by Sozobon, Limited.  Authors: Johann Ruegg, Don Dugger
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    dis3.c
  12.  */
  13. /*
  14.  * Modifications:
  15.  *    - in case of ailure to disassemble print operand as a constant
  16.  *      in 'dc.w' instruction
  17.  *    - make printout to align in a nicer way
  18.  *
  19.  *    Michal Jaegermann, November 1990
  20.  */
  21.  
  22. #include "adb.h"
  23.  
  24. extern long     dot;
  25. extern int      dotoff;
  26. extern int      opcode_pos;    /* this value depends on resolution */
  27.  
  28. #define DOT    (dot+dotoff)
  29.  
  30. int             cursz;
  31.  
  32. nextw ()
  33. {
  34.     return getwd ();
  35. }
  36.  
  37. long
  38. nextl ()
  39. {
  40.     unsigned int    i[2];
  41.  
  42.     i[0] = getwd ();
  43.     i[1] = getwd ();
  44.     return ((long) i[0]) << 16 | i[1];
  45. }
  46.  
  47. int             op0 (), op1 (), op2 (), op3 (), op4 (), op5 (), op6 (), op7 ();
  48. int             op8 (), op9 (), opa (), opb (), opc (), opd (), ope (), opf ();
  49.  
  50. int             (*funhi[]) () = { op0, op1, op2, op3, op4, op5, op6, op7,
  51.                   op8, op9, opa, opb, opc, opd, ope, opf
  52.                 };
  53.  
  54. puti ()
  55. {
  56.     unsigned int    op;
  57.     int             ar_pos;
  58.  
  59.     align (opcode_pos);
  60.  
  61.     op = nextw ();
  62.  
  63.     if (!(*funhi[op >> 12]) (op, ar_pos = opcode_pos + ALIGN_OP)) {
  64.     prt ("dc.w");
  65.     align (ar_pos);
  66.     prtn ((unsigned long) op, 0);
  67.     }
  68. }
  69.  
  70.  
  71. #define M_IMM    1
  72. #define M_PX    2
  73. #define M_POFF    4
  74. #define M_ABSL    010
  75. #define M_ABSW    020
  76. #define M_AX    040
  77. #define M_AOFF    0100
  78. #define M_ADEC    0200
  79. #define M_AINC    0400
  80. #define M_ATA    01000
  81. #define M_AREG    02000
  82. #define M_DREG    04000
  83.  
  84. valid (mode, reg, mask)
  85. {
  86.     if (mode == 7)
  87.     switch (reg) {
  88.     case 0:
  89.         return mask & M_ABSW;
  90.     case 1:
  91.         return mask & M_ABSL;
  92.     case 2:
  93.         return mask & M_POFF;
  94.     case 3:
  95.         return mask & M_PX;
  96.     case 4:
  97.         return mask & M_IMM;
  98.     default:
  99.         return 0;
  100.     }
  101.     else
  102.     switch (mode) {
  103.     case 0:
  104.         return mask & M_DREG;
  105.     case 1:
  106.         return mask & M_AREG;
  107.     case 2:
  108.         return mask & M_ATA;
  109.     case 3:
  110.         return mask & M_AINC;
  111.     case 4:
  112.         return mask & M_ADEC;
  113.     case 5:
  114.         return mask & M_AOFF;
  115.     case 6:
  116.         return mask & M_AX;
  117.     }
  118. }
  119.  
  120. ix_str (n)
  121. {
  122.     int             op, r;
  123.     char            c;
  124.     char           *fmt;
  125.  
  126.     op = nextw ();
  127.     r = (op >> 12) & 7;
  128.     c = (op & 0x800) ? 'l' : 'w';
  129.     if (n >= 8) {
  130.     if (op < 0)
  131.         fmt = "%i(pc,%a.%c)";
  132.     else
  133.         fmt = "%i(pc,%d.%c)";
  134.     prtf (fmt, (char) op, r, c);
  135.     }
  136.     else {
  137.     if (op < 0)
  138.         fmt = "%i(%a,%a.%c)";
  139.     else
  140.         fmt = "%i(%a,%d.%c)";
  141.     prtf (fmt, (char) op, n, r, c);
  142.     }
  143. }
  144.  
  145. modepr (mode, reg)
  146. {
  147.     char           *p;
  148.  
  149.     switch (mode) {
  150.     case 0:
  151.     prtf ("%d", reg);
  152.     break;
  153.     case 1:
  154.     prtf ("%a", reg);
  155.     break;
  156.     case 2:
  157.     prtf ("(%a)", reg);
  158.     break;
  159.     case 3:
  160.     prtf ("(%a)+", reg);
  161.     break;
  162.     case 4:
  163.     prtf ("-(%a)", reg);
  164.     break;
  165.     case 5:
  166.     prtf ("%i(%a)", nextw (), reg);
  167.     break;
  168.     case 6:
  169.     ix_str (reg);
  170.     break;
  171.     case 7:
  172.     switch (reg) {
  173.     case 0:
  174.         prtf ("%i", nextw ());
  175.         break;
  176.     case 1:
  177.         longval ();
  178.         break;
  179.     case 2:
  180.         prtf ("%i(pc)", nextw ());
  181.         break;
  182.     case 3:
  183.         ix_str (8);
  184.         break;
  185.     case 4:
  186.         switch (cursz) {
  187.         case 0:
  188.         case 1:
  189.         prtf ("#%i", nextw ());
  190.         break;
  191.         case 2:
  192.         putchr ('#');
  193.         longval ();
  194.         break;
  195.         }
  196.         break;
  197.     }
  198.     }
  199. }
  200.  
  201. longval ()
  202. {
  203.     long            l;
  204.     struct sym     *sp;
  205.  
  206.     prtf ("%A", nextl ());
  207. }
  208.  
  209. char            szchr[] = {'b', 'w', 'l'};
  210.  
  211. struct optbl {
  212.     char            sel[6];
  213.     char           *name;
  214.     int             allow;
  215.     char            arg[4];
  216.     char            sz;
  217. };
  218.  
  219. struct optbl    t0[] = {
  220.             {"0s", "or", 05770, "ie"},
  221.             {"00", "or", 1, "ic"},
  222.             {"01", "or", 1, "is", 1},
  223.             {"*4", "btst", 05777, "De"},
  224.             {"*5", "bchg", 05770, "De"},
  225.             {"*6", "bclr", 05770, "De"},
  226.             {"*7", "bset", 05770, "De"},
  227.             {"*4", "movep.w", 02000, "oD"},
  228.             {"*5", "movep.l", 02000, "oD"},
  229.             {"*6", "movep.w", 02000, "Do"},
  230.             {"*7", "movep.l", 02000, "Do"},
  231.             {"1s", "and", 05770, "ie"},
  232.             {"10", "and", 1, "ic"},
  233.             {"11", "and", 1, "is", 1},
  234.             {"2s", "sub", 05770, "ie"},
  235.             {"3s", "add", 05770, "ie"},
  236.             {"40", "btst", 05776, "ie"},
  237.             {"41", "bchg", 05770, "ie"},
  238.             {"42", "bclr", 05770, "ie"},
  239.             {"43", "bset", 05770, "ie"},
  240.             {"5s", "eor", 05770, "ie"},
  241.             {"50", "eor", 1, "ic"},
  242.             {"51", "eor", 1, "is", 1},
  243.             {"6s", "cmp", 05770, "ie"},
  244.             {0, 0, 0, 0}
  245. };
  246.  
  247. op0 (op, pos)
  248.     unsigned int    op;
  249.     int             pos;
  250. {
  251.     return tblop (op, t0, pos);
  252. }
  253.  
  254. match (c, val)
  255. {
  256.     switch (c) {
  257.     case '*':
  258.     return 1;
  259.     case 's':
  260.     return val <= 2;
  261.     case 'S':
  262.     return val >= 4 && val <= 6;
  263.     case 'z':
  264.     return val >= 1 && val <= 2;
  265.     case 'Z':
  266.     return val == 3 || val == 7;
  267.     default:
  268.     return val == (c - '0');
  269.     }
  270. }
  271.  
  272. op1 (op, pos)
  273.     unsigned int    op;
  274.     int             pos;
  275. {
  276.     int             sm, sr, dm, dr;
  277.  
  278.     sm = (op >> 3) & 7;
  279.     sr = op & 7;
  280.     dm = (op >> 6) & 7;
  281.     dr = (op >> 9) & 7;
  282.     cursz = 0;
  283.     if (valid (sm, sr, 07777) && valid (dm, dr, 05770)) {
  284.     prt ("move.b");
  285.     align (pos);
  286.     modepr (sm, sr);
  287.     putchr (',');
  288.     modepr (dm, dr);
  289.     return 1;
  290.     }
  291.     return 0;
  292. }
  293.  
  294. op2 (op, pos)
  295.     unsigned int    op;
  296.     int             pos;
  297. {
  298.     int             sm, sr, dm, dr;
  299.  
  300.     sm = (op >> 3) & 7;
  301.     sr = op & 7;
  302.     dm = (op >> 6) & 7;
  303.     dr = (op >> 9) & 7;
  304.     cursz = 2;
  305.     if (valid (sm, sr, 07777) && valid (dm, dr, 07770)) {
  306.     prt ("move.l");
  307.     align (pos);
  308.     modepr (sm, sr);
  309.     putchr (',');
  310.     modepr (dm, dr);
  311.     return 1;
  312.     }
  313.     return 0;
  314. }
  315.  
  316. op3 (op, pos)
  317.     unsigned int    op;
  318.     int             pos;
  319. {
  320.     int             sm, sr, dm, dr;
  321.  
  322.     sm = (op >> 3) & 7;
  323.     sr = op & 7;
  324.     dm = (op >> 6) & 7;
  325.     dr = (op >> 9) & 7;
  326.     cursz = 1;
  327.     if (valid (sm, sr, 07777) && valid (dm, dr, 07770)) {
  328.     prt ("move.w");
  329.     align (pos);
  330.     modepr (sm, sr);
  331.     putchr (',');
  332.     modepr (dm, dr);
  333.     return 1;
  334.     }
  335.     return 0;
  336. }
  337.  
  338. struct optbl    t4[] = {
  339.             {"0s", "negx", 05770, "e"},
  340.             {"03", "move.w", 05770, "se"},
  341.             {"*6", "chk", 05777, "eD"},
  342.             {"*7", "lea", 01176, "eA"},
  343.             {"1s", "clr", 05770, "e"},
  344.             {"2s", "neg", 05770, "e"},
  345.             {"23", "move.b", 05777, "ec"},
  346.             {"3s", "not", 05770, "e"},
  347.             {"33", "move.w", 05777, "es", 1},
  348.             {"40", "nbcd", 05770, "e"},
  349.             {"41", "swap", 04000, "d"},
  350.             {"41", "pea", 01176, "e"},
  351.             {"42", "ext.w", 04000, "d"},
  352.             {"42", "movem.w", 01170, "le"},
  353.             {"42", "movem.w", 00200, "Le"},
  354.             {"43", "movem.l", 01170, "le"},
  355.             {"43", "movem.l", 00200, "Le"},
  356.             {"43", "ext.l", 04000, "d"},
  357.             {"5s", "tst", 05770, "e"},
  358.             {"53", "tas", 05770, "e"},
  359.             {"53", "illegal", 0001, ""},
  360.             {"71", "trap", 06000, "t"},
  361.             {"71", "link", 01000, "ai", 1},
  362.             {"71", "unlk", 00400, "a"},
  363.             {"71", "move", 00200, "au"},
  364.             {"71", "move", 00100, "ua"},
  365.             {"7160", "reset", 0, ""},
  366.             {"7161", "nop", 0, ""},
  367.             {"7162", "stop", 0, ""},
  368.             {"7163", "rte", 0, ""},
  369.             {"7165", "rts", 0, ""},
  370.             {"7166", "trapv", 0, ""},
  371.             {"7167", "rtr", 0, ""},
  372.             {"72", "jsr", 01176, "e"},
  373.             {"73", "jmp", 01176, "e"},
  374.             {0, 0, 0, 0}
  375. };
  376.  
  377. op4 (op, pos)
  378.     unsigned int    op;
  379.     int             pos;
  380. {
  381.     int             mode, reg, list;
  382.  
  383.     if ((op & 07600) == 06200) {
  384.     reg = op & 7;
  385.     mode = (op >> 3) & 7;
  386.     if (valid (mode, reg, 01576)) {
  387.         prtf ("movem.%c", op & 0100 ? 'l' : 'w');
  388.         align (pos);
  389.         list = nextw ();
  390.         modepr (mode, reg);
  391.         putchr (',');
  392.         rlist (list);
  393.         return 1;
  394.     }
  395.     else
  396.         return 0;
  397.     }
  398.     return tblop (op, t4, pos);
  399. }
  400.  
  401. tblop (op, tp, pos)
  402.     unsigned        op;
  403.     register struct optbl